home *** CD-ROM | disk | FTP | other *** search
/ MACD 5 / MACD 5.bin / workbench / wb / czesc_1 / cgwbpattern101 / ilbmtoppm.lha / src / ilbmtoppm.c < prev    next >
C/C++ Source or Header  |  1995-03-29  |  71KB  |  2,260 lines
  1. /* ilbmtoppm.c - read an IFF ILBM file and produce a portable pixmap
  2. **
  3. ** Copyright (C) 1989 by Jef Poskanzer.
  4. **
  5. ** Permission to use, copy, modify, and distribute this software and its
  6. ** documentation for any purpose and without fee is hereby granted, provided
  7. ** that the above copyright notice appear in all copies and that both that
  8. ** copyright notice and this permission notice appear in supporting
  9. ** documentation.  This software is provided "as is" without express or
  10. ** implied warranty.
  11. **
  12. ** Modified by Mark Thompson on 10/4/90 to accomodate 24-bit IFF files
  13. ** as used by ASDG, NewTek, etc.
  14. **
  15. ** Modified by Ingo Wilken (Ingo.Wilken@informatik.uni-oldenburg.de)
  16. **  20/Jun/93:
  17. **  - row-by-row operation
  18. **  - better de-interleave algorithm
  19. **  - colormap files
  20. **  - direct color
  21. **  04/Oct/93:
  22. **  - multipalette support (PCHG chunk)
  23. **  - options -ignore, -isham, -isehb and -adjustcolors
  24. **  22/May/94:
  25. **  - minor change: check first for 24 planes, then for HAM
  26. **  21/Sep/94:
  27. **  - write mask plane to a file if -maskfile option used
  28. **  - write colormap file
  29. **  - added sliced HAM/dynamic HAM/dynamic Hires multipalette formats (SHAM, CTBL chunk)
  30. **  - added color lookup tables (CLUT chunk)
  31. **  - major rework of colormap/multipalette handling
  32. **  - now uses numeric IFF IDs
  33. **  24/Oct/94:
  34. **  - transparentColor support
  35. **  - added RGBN/RGB8 image types
  36. **  - 24-bit & direct color modified to n-bit deep ILBM
  37. **  22/Feb/95:
  38. **  - direct color (DCOL) reimplemented
  39. **  29/Mar/95
  40. **  - added IFF-PBM format
  41. */
  42.  
  43. #include "ppm.h"
  44. #include "pbm.h"
  45. #include "ilbm.h"
  46.  
  47. /* as long as the libcmap2 routines are not part of the "official"
  48.  * libppm we cheat by including the C-source here...
  49.  */
  50. #include "libcmap2.c"
  51. /*#include "ppmcmap2.h"*/
  52.  
  53. /*#define DEBUG*/
  54.  
  55. typedef struct {
  56.     int reg;            /* color register to change */
  57.     pixval r, g, b;     /* new colors for register */
  58. } PaletteChange;
  59. typedef struct {
  60.     pixel *color;
  61.     int    ncolors;
  62.     /* lookup tables */
  63.     unsigned char *redlut;
  64.     unsigned char *greenlut;
  65.     unsigned char *bluelut;
  66.     unsigned char *monolut;
  67.     /* multipalette stuff */
  68.     PaletteChange *mp_init;
  69.     PaletteChange **mp_change;
  70.     int mp_rows;                /* # of rows in change array */
  71.     int mp_type;                /* see below, higher types preferred */
  72.     int mp_flags;
  73.     IFF_ID  mp_id;
  74. } ColorMap;
  75. #define HAS_COLORMAP(cmap)      ((cmap) && (cmap)->color)
  76. #define HAS_COLORLUT(cmap)      ((cmap) && ((cmap)->redlut || (cmap)->greenlut || (cmap)->bluelut))
  77. #define HAS_MONOLUT(cmap)       ((cmap) && (cmap)->monolut)
  78. #define HAS_MULTIPALETTE(cmap)  (HAS_COLORMAP(cmap) && (cmap)->mp_type)
  79. #define MP_TYPE_SHAM        1
  80. #define MP_TYPE_CTBL        2
  81. #define MP_TYPE_PCHG        3
  82. #define MP_REG_IGNORE       -1
  83. #define MP_REG_END          -2
  84. #define MP_FLAGS_SKIPLACED   (1<<0)
  85.  
  86.  
  87. /* prototypes */
  88. static unsigned char get_byte ARGS((FILE* f, IFF_ID iffid, long *counter));
  89. static long get_big_long ARGS((FILE *f, IFF_ID iffid, long *counter));
  90. static short get_big_short ARGS((FILE *f, IFF_ID iffid, long *counter));
  91. static void read_bytes ARGS((FILE *ifp, int bytes, unsigned char *buffer, IFF_ID iffid, long *counter));
  92. static char *ID2string ARGS((IFF_ID iffid));
  93.  
  94. static void chunk_end ARGS((FILE *ifp, IFF_ID iffid, long chunksize));
  95. static void skip_chunk ARGS((FILE *f, IFF_ID iffid, long chunksize));
  96. static void display_chunk ARGS((FILE *ifp, IFF_ID iffid, long chunksize));
  97. static BitMapHeader * read_bmhd ARGS((FILE *f, IFF_ID iffid, long chunksize));
  98. static ColorMap * read_cmap ARGS((FILE *f, IFF_ID iffid, long chunksize, ColorMap *cmap));
  99. static ColorMap * read_cmyk ARGS((FILE *f, IFF_ID iffid, long chunksize, ColorMap *cmap));
  100. static ColorMap * read_clut ARGS((FILE *f, IFF_ID iffid, long chunksize, ColorMap *cmap));
  101. static ColorMap * read_4bit_mp ARGS((FILE *ifp, IFF_ID iffid, long chunksize, ColorMap *cmap));
  102. static ColorMap * read_pchg ARGS((FILE *ifp, IFF_ID iffid, long chunksize, ColorMap *cmap));
  103.  
  104. static void ham_to_ppm ARGS((FILE *ifp, long chunksize, BitMapHeader *bmhd, ColorMap *colormap, long viewportmodes));
  105. static void deep_to_ppm ARGS((FILE *ifp, long chunksize, BitMapHeader *bmhd, ColorMap *cmap));
  106. static void cmap_to_ppm ARGS((ColorMap *colormap));
  107. static void std_to_ppm ARGS((FILE *ifp, long chunksize, BitMapHeader *bmhd, ColorMap *colormap, long viewportmodes));
  108. static void rgbn_to_ppm ARGS((FILE *ifp, long chunksize, BitMapHeader *bmhd, ColorMap *cmap));
  109. static void dcol_to_ppm ARGS((FILE *ifp, long chunksize, BitMapHeader *bmhd, ColorMap *cmap, DirectColor *dcol));
  110. static void ipbm_to_ppm ARGS((FILE *ifp, long chunksize, BitMapHeader *bmhd, ColorMap *cmap, long viewportmodes));
  111.  
  112. static ColorMap* ehbcmap ARGS((ColorMap *colormap));
  113. static void read_ilbm_plane ARGS((FILE *ifp, long *chunksizeP, int bytes, int compression));
  114. static void decode_row ARGS((FILE *ifp, long *chunksizeP, rawtype *chunkyrow, int planes, BitMapHeader *bmhd));
  115. static void decode_mask ARGS((FILE *ifp, long *chunksizeP, rawtype *chunkyrow, BitMapHeader *bmhd));
  116.  
  117. static void get_color ARGS((ColorMap *cmap, int idx, pixval *r, pixval *g, pixval *b));
  118. static pixval lookup_red ARGS((ColorMap *cmap, int oldval));
  119. static pixval lookup_green ARGS((ColorMap *cmap, int oldval));
  120. static pixval lookup_blue ARGS((ColorMap *cmap, int oldval));
  121. static pixval lookup_mono ARGS((ColorMap *cmap, int oldval));
  122. static pixval lut_maxval ARGS((ColorMap *cmap, pixval maxval));
  123.  
  124. static void multi_init ARGS((ColorMap *cmap, long viewportmodes));
  125. static void multi_update ARGS((ColorMap *cmap, int row));
  126. static void multi_free ARGS((ColorMap *cmap));
  127.  
  128. static rawtype * alloc_rawrow ARGS((int cols));
  129. static ColorMap * alloc_cmap ARGS((void));
  130. static void check_cmap ARGS((BitMapHeader *bmhd, ColorMap *cmap));
  131. static void * xmalloc ARGS((int bytes));
  132. #define MALLOC(n, type)     (type *)xmalloc((n) * sizeof(type))
  133.  
  134. #define FACTOR_4BIT     17      /* scale factor maxval 15 -> maxval 255 */
  135.  
  136. static short verbose = 0;
  137. static short adjustcolors = 0;
  138. static unsigned char *ilbmrow;
  139. static pixel *pixelrow;
  140. static FILE *maskfile = NULL;
  141. static bit *maskrow = NULL;
  142. static short wrotemask = 0;
  143. static IFF_ID typeid;       /* ID_ILBM, ID_RGBN, ID_RGB8 */
  144.  
  145. static pixel *transpColor = NULL;       /* transparent color */
  146. static short transpIndex = -1;
  147. static char *transpName = NULL;
  148.  
  149. int
  150. main(argc, argv)
  151.     int argc;
  152.     char *argv[];
  153. {
  154.     FILE *ifp;
  155.     int argn;
  156.     short body = 0, cmaponly = 0, isdeep = 0, endchunk = 0;
  157.     long formsize, bytesread, chunksize, viewportmodes = 0, fakeviewport = 0, viewportmask;
  158.     IFF_ID iffid;
  159.     BitMapHeader *bmhd = NULL;
  160.     ColorMap *cmap = NULL;
  161.     DirectColor *dcol = NULL;
  162. #define MAX_IGNORE  16
  163.     IFF_ID ignorelist[MAX_IGNORE];
  164.     int ignorecount = 0;
  165.     char *maskname;
  166.     char *usage =
  167. "[-verbose] [-ignore <chunkID> [-ignore <chunkID>] ...]\
  168.  [-isham|-isehb|-isdeep|-isnotham|-isnotehb|-isnotdeep]\
  169.  [-cmaponly] [-adjustcolors]\
  170.  [-transparent <color>] [-maskfile <filename>] [ilbmfile]";
  171.  
  172.     ppm_init(&argc, argv);
  173.  
  174.     viewportmask = 0xffffffff;
  175.  
  176.     argn = 1;
  177.     while( argn < argc && argv[argn][0] == '-' && argv[argn][1] != '\0' ) {
  178.         if( pm_keymatch(argv[argn], "-verbose", 2) )
  179.             verbose = 1;
  180.         else
  181.         if( pm_keymatch(argv[argn], "-noverbose", 4) )
  182.             verbose = 0;
  183.         else
  184.         if( pm_keymatch(argv[argn], "-isham", 4) )
  185.             fakeviewport |= vmHAM;
  186.         else
  187.         if( pm_keymatch(argv[argn], "-isehb", 4) )
  188.             fakeviewport |= vmEXTRA_HALFBRITE;
  189.         else
  190.         if( pm_keymatch(argv[argn], "-isdeep", 4) )
  191.             isdeep = 1;
  192.         else
  193.         if( pm_keymatch(argv[argn], "-isnotham", 7) )
  194.             viewportmask &= ~(vmHAM);
  195.         else
  196.         if( pm_keymatch(argv[argn], "-isnotehb", 7) )
  197.             viewportmask &= ~(vmEXTRA_HALFBRITE);
  198.         else
  199.         if( pm_keymatch(argv[argn], "-isnotdeep", 7) )
  200.             isdeep = -1;
  201.         else
  202.         if( pm_keymatch(argv[argn], "-cmaponly", 2) )
  203.             cmaponly = 1;
  204.         else
  205.         if( pm_keymatch(argv[argn], "-adjustcolors", 2) )
  206.             adjustcolors = 1;
  207.         else
  208.         if( pm_keymatch(argv[argn], "-noadjustcolors", 4) )
  209.             adjustcolors = 0;
  210.         else
  211.         if( pm_keymatch(argv[argn], "-transparent", 2) ) {
  212.             if( ++argn >= argc )
  213.                 pm_usage(usage);
  214.             transpName = argv[argn];
  215.         }
  216.         else
  217.         if( pm_keymatch(argv[argn], "-maskfile", 2) ) {
  218.             if( ++argn >= argc )
  219.                 pm_usage(usage);
  220.             maskname = argv[argn];
  221.             maskfile = pm_openw(maskname);
  222.         }
  223.         else
  224.         if( pm_keymatch(argv[argn], "-ignore", 2) ) {
  225.             if( ++argn >= argc )
  226.                 pm_usage(usage);
  227.             if( strlen(argv[argn]) != 4 )
  228.                 pm_error("\"-ignore\" option needs a 4 byte chunk ID string as argument");
  229.             if( ignorecount >= MAX_IGNORE )
  230.                 pm_error("max %d chunk IDs to ignore", MAX_IGNORE);
  231.             ignorelist[ignorecount++] = MAKE_ID(argv[argn][0], argv[argn][1], argv[argn][2], argv[argn][3]);
  232.         }
  233.         else
  234.             pm_usage(usage);
  235.         ++argn;
  236.     }
  237.  
  238.     if( argn < argc ) {
  239.         ifp = pm_openr( argv[argn] );
  240.         argn++;
  241.     }
  242.     else
  243.         ifp = stdin;
  244.  
  245.     if( argn != argc )
  246.         pm_usage(usage);
  247.  
  248.     /* Read in the ILBM file. */
  249.     iffid = get_big_long(ifp, ID_FORM, NULL);
  250.     if( iffid != ID_FORM )
  251.         pm_error("input is not a FORM type IFF file");
  252.     formsize = get_big_long(ifp, ID_FORM, NULL);
  253.     typeid = get_big_long(ifp, ID_FORM, NULL);
  254.     if( typeid != ID_ILBM && typeid != ID_RGBN && typeid != ID_RGB8 && typeid != ID_PBM )
  255.         pm_error( "input is not an ILBM, RGBN, RGB8 or PBM type FORM IFF file" );
  256.     bytesread = 4;  /* FORM and formsize do not count */
  257.  
  258.     /* Main loop, parsing the IFF FORM. */
  259.     while( !endchunk && formsize-bytesread >= 8 ) {
  260.         short i, ignore = 0;
  261.  
  262.         iffid = get_big_long(ifp, ID_FORM, NULL);
  263.         chunksize = get_big_long(ifp, iffid, NULL);
  264.         bytesread += 8;
  265.  
  266.         for( i = 0; i < ignorecount && !ignore; i++ ) {
  267.             if( iffid == ignorelist[i] )
  268.                 ignore = 1;
  269.         }
  270.  
  271. #ifdef DEBUG
  272.             pm_message("reading %s chunk: %ld bytes", ID2string(iffid), chunksize);
  273. #endif
  274.         if( ignore ) {
  275.             ignore = 0;
  276.             pm_message("ignoring %s chunk", ID2string(iffid));
  277.             skip_chunk(ifp, iffid, chunksize);
  278.         }
  279.         else
  280.         if( iffid == ID_END ) {
  281.             /* END chunks are not officially supported in IFF, but
  282.                 suggested as a future expansion for stream-writing,
  283.                 see Amiga RKM Devices, 3rd Ed, page 376 */
  284.             if( chunksize != 0 ) {
  285.                 pm_message("warning - non-0 %s chunk", ID2string(iffid));
  286.                 skip_chunk(ifp, iffid, chunksize);
  287.             }
  288.             if( formsize != 0xffffffff )
  289.                 pm_message("warning - %s chunk with FORM size 0x%08lx (should be 0x%08lx)",
  290.                             ID2string(iffid), formsize, 0xffffffff);
  291.             endchunk = 1;
  292.         }
  293.         else
  294.         if( body != 0 ) {
  295.             pm_message("%s chunk found after %s chunk - skipping", ID2string(iffid), ID2string(ID_BODY));
  296.             skip_chunk(ifp, iffid, chunksize);
  297.         }
  298.         else
  299.         switch( iffid ) {
  300.             case ID_BMHD:
  301.                 bmhd = read_bmhd(ifp, iffid, chunksize);
  302.                 if( bmhd->nPlanes == 0 )
  303.                     cmaponly = 1;
  304.                 break;
  305.             case ID_CMAP:
  306.                 cmap = read_cmap(ifp, iffid, chunksize, cmap);
  307.                 break;
  308.             case ID_CMYK:
  309.                 cmap = read_cmyk(ifp, iffid, chunksize, cmap);
  310.                 break;
  311.             case ID_CLUT:
  312.                 cmap = read_clut(ifp, iffid, chunksize, cmap);
  313.                 break;
  314.             case ID_CAMG:
  315.                 if( chunksize != CAMGChunkSize )
  316.                     pm_error("%s chunk size mismatch", ID2string(iffid));
  317.                 viewportmodes = get_big_long(ifp, ID_CAMG, NULL);
  318.                 viewportmodes &= viewportmask;      /* -isnotham/-isnotehb */
  319.                 break;
  320.             case ID_PCHG:
  321.                 cmap = read_pchg(ifp, iffid, chunksize, cmap);
  322.                 break;
  323.             case ID_CTBL:
  324.             case ID_SHAM:
  325.                 cmap = read_4bit_mp(ifp, iffid, chunksize, cmap);
  326.                 break;
  327.             case ID_DCOL:
  328.                 if( chunksize != DirectColorSize )
  329.                     pm_error("%s chunk size mismatch", ID2string(iffid));
  330.                 dcol = MALLOC(1, DirectColor);
  331.                 dcol->r = get_byte(ifp, iffid, NULL);
  332.                 dcol->g = get_byte(ifp, iffid, NULL);
  333.                 dcol->b = get_byte(ifp, iffid, NULL);
  334.                 (void)get_byte(ifp, iffid, NULL);       /* skip pad byte */
  335.                 break;
  336.             case ID_BODY:
  337.                 body = 1;
  338.  
  339.                 if( bmhd == NULL )
  340.                     pm_error("%s chunk without %s chunk", ID2string(ID_BODY), ID2string(ID_BMHD));
  341.  
  342.                 if( cmaponly ) {
  343.                     skip_chunk(ifp, iffid,  chunksize);
  344.                     break;
  345.                 }
  346.  
  347.                 check_cmap(bmhd, cmap);
  348.  
  349.                 pixelrow = ppm_allocrow(bmhd->w);
  350.                 if( maskfile ) {
  351.                     maskrow = pbm_allocrow(bmhd->w);
  352.                     pbm_writepbminit(maskfile, bmhd->w, bmhd->h, 0);
  353.                 }
  354.  
  355.                 if( typeid == ID_ILBM ) {
  356.                     ilbmrow = MALLOC(RowBytes(bmhd->w), unsigned char);
  357.                     viewportmodes |= fakeviewport;      /* -isham/-isehb */
  358.  
  359.                     if( isdeep > 0 && (bmhd->nPlanes % 3 != 0) ) {
  360.                         pm_message("cannot interpret %d-plane image as \'deep\' (# of planes must be divisible by 3)", bmhd->nPlanes);
  361.                         isdeep = 0;
  362.                     }
  363.  
  364.                     if( isdeep > 0 )
  365.                         deep_to_ppm(ifp, chunksize, bmhd, cmap);
  366.                     else
  367.                     if( dcol )
  368.                         dcol_to_ppm(ifp, chunksize, bmhd, cmap, dcol);
  369.                     else
  370.                     if( bmhd->nPlanes > 8 ) {
  371.                         if( bmhd->nPlanes <= 16 && HAS_COLORMAP(cmap) )
  372.                             std_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes);
  373.                         else
  374.                         if( isdeep >= 0 && (bmhd->nPlanes % 3 == 0) )
  375.                             deep_to_ppm(ifp, chunksize, bmhd, cmap);
  376.                         else
  377.                         if( bmhd->nPlanes <= 16 )   /* will be interpreted as grayscale */
  378.                             std_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes);
  379.                         else
  380.                             pm_error("don\'t know how to interpret %d-plane image", bmhd->nPlanes);
  381.                     }
  382.                     else
  383.                         std_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes);
  384.                 }
  385.                 else
  386.                 if( typeid == ID_PBM )
  387.                     ipbm_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes);
  388.                 else   /* RGBN or RGB8 */
  389.                     rgbn_to_ppm(ifp, chunksize, bmhd, cmap);
  390.                 break;
  391.             case ID_GRAB:   case ID_DEST:   case ID_SPRT:   case ID_CRNG:
  392.             case ID_CCRT:   case ID_DYCP:   case ID_DPPV:   case ID_DRNG:
  393.             case ID_EPSF:   case ID_JUNK:   case ID_CNAM:   case ID_PRVW:
  394.                 skip_chunk(ifp, iffid, chunksize);
  395.                 break;
  396.             case ID_copy:   case ID_AUTH:   case ID_NAME:   case ID_ANNO:
  397.             case ID_TEXT:   case ID_FVER:
  398.                 if( verbose )
  399.                     display_chunk(ifp, iffid, chunksize);
  400.                 else
  401.                     skip_chunk(ifp, iffid, chunksize);
  402.                 break;
  403.             case ID_DPI:
  404.                 {
  405.                     int x, y;
  406.  
  407.                     x = get_big_short(ifp, ID_DPI, NULL);
  408.                     y = get_big_short(ifp, ID_DPI, NULL);
  409.                     if( verbose )
  410.                         pm_message("%s chunk:  dpi_x = %d    dpi_y = %d", ID2string(ID_DPI), x, y);
  411.                 }
  412.                 break;
  413.             default:
  414.                 pm_message("unknown chunk type %s - skipping", ID2string(iffid));
  415.                 skip_chunk(ifp, iffid, chunksize);
  416.                 break;
  417.         }
  418.  
  419.         bytesread += chunksize;
  420.         if( odd(chunksize) ) {
  421.             (void) get_byte(ifp, iffid, NULL);
  422.             ++bytesread;
  423.         }
  424.     }
  425.  
  426.     if( maskfile ) {
  427.         pm_close(maskfile);
  428.         if( !wrotemask )
  429.             remove(maskname);
  430.         pbm_freerow(maskrow);
  431.     }
  432.  
  433.     if( cmaponly ) {
  434.         if( HAS_COLORMAP(cmap) ) {
  435.             check_cmap(bmhd, cmap);
  436.             cmap_to_ppm(cmap);
  437.         }
  438.         else
  439.             pm_error("no colormap");
  440.     }
  441.     else
  442.     if( body == 0 ) {
  443.         if( HAS_COLORMAP(cmap) ) {
  444.             pm_message("input is a colormap file");
  445.             check_cmap(bmhd, cmap);
  446.             cmap_to_ppm(cmap);
  447.         }
  448.         else
  449.             pm_error("no %s or %s chunk found", ID2string(ID_BODY), ID2string(ID_CMAP));
  450.     }
  451.  
  452.     for(chunksize = 0; fgetc(ifp) != EOF; chunksize++ )
  453.         bytesread++;
  454.     pm_close(ifp);
  455.  
  456.     if( chunksize )
  457.         pm_message("skipped %ld extraneous byte%s after last chunk",
  458.                     chunksize, (chunksize == 1 ? "" : "s"));
  459.  
  460.     if( !endchunk && bytesread != formsize ) {
  461.         pm_message("warning - file length/FORM size field mismatch (%ld != %ld+8)",
  462.                     bytesread+8 /* FORM+size */, formsize);
  463.     }
  464.  
  465.     exit(0);
  466. }
  467.  
  468.  
  469. /****************************************************************************
  470.  Chunk reader
  471.  ****************************************************************************/
  472.  
  473. static void
  474. chunk_end(ifp, iffid, chunksize)
  475.     FILE *ifp;
  476.     IFF_ID iffid;
  477.     long chunksize;
  478. {
  479.     if( chunksize ) {
  480.         pm_message("warning - %ld extraneous byte%s in %s chunk",
  481.                     chunksize, (chunksize == 1 ? "" : "s"), ID2string(iffid));
  482.         while( chunksize )
  483.             (void) get_byte(ifp, iffid, &chunksize);
  484.     }
  485. }
  486.  
  487.  
  488. static void
  489. skip_chunk(ifp, iffid, chunksize)
  490.     FILE *ifp;
  491.     IFF_ID iffid;
  492.     long chunksize;
  493. {
  494.     while( chunksize )
  495.         (void) get_byte(ifp, iffid, &chunksize);
  496. }
  497.  
  498.  
  499. static void
  500. display_chunk(ifp, iffid, chunksize)
  501.     FILE *ifp;
  502.     IFF_ID iffid;
  503.     long chunksize;
  504. {
  505.     int byte;
  506.  
  507.     pm_message("contents of %s chunk:", ID2string(iffid));
  508.  
  509.     while( chunksize ) {
  510.         byte = get_byte(ifp, iffid, &chunksize);
  511.         if( fputc(byte, stderr) == EOF )
  512.             pm_error("write error");
  513.     }
  514.     if( byte != '\n' )
  515.         if( fputc('\n', stderr) == EOF )
  516.             pm_error("write error");
  517. }
  518.  
  519.  
  520. static ColorMap *
  521. read_cmap(ifp, iffid, chunksize, cmap)
  522.     FILE *ifp;
  523.     IFF_ID iffid;
  524.     long chunksize;
  525.     ColorMap *cmap;
  526. {
  527.     int i, r, g, b;
  528.     long colors;
  529.  
  530.     colors = chunksize / 3;
  531.     if( colors == 0 ) {
  532.         pm_error("warning - empty %s colormap", ID2string(iffid));
  533.         skip_chunk(ifp, iffid, chunksize);
  534.         return cmap;
  535.     }
  536.  
  537.     if( !cmap )
  538.         cmap = alloc_cmap();
  539.     else
  540.     if( cmap->color )               /* prefer CMAP-chunk over CMYK-chunk */
  541.         ppm_freerow(cmap->color);
  542.     cmap->color = ppm_allocrow(colors);
  543.     cmap->ncolors = colors;
  544.  
  545.     for( i = 0; i < colors; i++ ) {
  546.         r = get_byte(ifp, iffid, &chunksize);
  547.         g = get_byte(ifp, iffid, &chunksize);
  548.         b = get_byte(ifp, iffid, &chunksize);
  549.         PPM_ASSIGN(cmap->color[i], r, g, b);
  550.     }
  551.     chunk_end(ifp, iffid, chunksize);
  552.     return cmap;
  553. }
  554.  
  555.  
  556. static ColorMap *
  557. read_cmyk(ifp, iffid, chunksize, cmap)
  558.     FILE *ifp;
  559.     IFF_ID iffid;
  560.     long chunksize;
  561.     ColorMap *cmap;
  562. {
  563.     long colors;
  564.     int i;
  565.  
  566.     if( HAS_COLORMAP(cmap) ) {      /* prefer RGB color map */
  567.         skip_chunk(ifp, iffid, chunksize);
  568.         return cmap;
  569.     }
  570.  
  571.     colors = chunksize/4;
  572.     if( colors == 0 ) {
  573.         pm_error("warning - empty %s colormap", ID2string(iffid));
  574.         skip_chunk(ifp, iffid, chunksize);
  575.         return cmap;
  576.     }
  577.     if( !cmap )
  578.         cmap = alloc_cmap();
  579.     cmap->color = ppm_allocrow(colors);
  580.     cmap->ncolors = colors;
  581.  
  582.     for( i = 0; i <colors; i++ ) {
  583.         int c, m, y, k;
  584.         c = get_byte(ifp, iffid, &chunksize);
  585.         m = get_byte(ifp, iffid, &chunksize);
  586.         y = get_byte(ifp, iffid, &chunksize);
  587.         k = get_byte(ifp, iffid, &chunksize);
  588.  
  589.         c = MAXCOLVAL - min(MAXCOLVAL, c*(MAXCOLVAL-k)+k);  /* cyan -> red */
  590.         m = MAXCOLVAL - min(MAXCOLVAL, m*(MAXCOLVAL-k)+k);  /* magenta -> green */
  591.         y = MAXCOLVAL - min(MAXCOLVAL, y*(MAXCOLVAL-k)+k);  /* yellow -> blue */
  592.         PPM_ASSIGN(cmap->color[i], c, m, y);
  593.     }
  594.     chunk_end(ifp, iffid, chunksize);
  595.     return cmap;
  596. }
  597.  
  598.  
  599. static ColorMap *
  600. read_clut(ifp, iffid, chunksize, cmap)
  601.     FILE *ifp;
  602.     IFF_ID iffid;
  603.     long chunksize;
  604.     ColorMap *cmap;
  605. {
  606.     long type;
  607.     unsigned char *lut;
  608.     int i;
  609.  
  610.     if( chunksize != CLUTSize ) {
  611.         pm_message("invalid size for %s chunk - skipping it", ID2string(iffid));
  612.         skip_chunk(ifp, iffid, chunksize);
  613.         return cmap;
  614.     }
  615.  
  616.     if( !cmap )
  617.         cmap = alloc_cmap();
  618.  
  619.     type = get_big_long(ifp, iffid, &chunksize);
  620.     (void) get_big_long(ifp, iffid, &chunksize);    /* skip reserved field */
  621.  
  622.     lut = MALLOC(256, unsigned char);
  623.     for( i = 0; i < 256; i++ )
  624.         lut[i] = get_byte(ifp, iffid, &chunksize);
  625.  
  626.     switch( type ) {
  627.         case CLUT_MONO:
  628.             cmap->monolut = lut;
  629.             break;
  630.         case CLUT_RED:
  631.             cmap->redlut = lut;
  632.             break;
  633.         case CLUT_GREEN:
  634.             cmap->greenlut = lut;
  635.             break;
  636.         case CLUT_BLUE:
  637.             cmap->bluelut = lut;
  638.             break;
  639.         default:
  640.             pm_message("warning - %s type %ld not supported", ID2string(iffid), type);
  641.             free(lut);
  642.     }
  643.     return cmap;
  644. }
  645.  
  646.  
  647. static BitMapHeader *
  648. read_bmhd(ifp, iffid, chunksize)
  649.     FILE *ifp;
  650.     IFF_ID iffid;
  651.     long chunksize;
  652. {
  653.     BitMapHeader *bmhd;
  654.  
  655.     if( chunksize != BitMapHeaderSize ) {
  656.         pm_message("invalid size for %s chunk - skipping it", ID2string(iffid));
  657.         skip_chunk(ifp, iffid, chunksize);
  658.         return NULL;
  659.     }
  660.  
  661.     bmhd = MALLOC(1, BitMapHeader);
  662.  
  663.     bmhd->w = get_big_short(ifp, iffid, &chunksize);        /* cols */
  664.     bmhd->h = get_big_short(ifp, iffid, &chunksize);        /* rows */
  665.     bmhd->x = get_big_short(ifp, iffid, &chunksize);        /* ignored */
  666.     bmhd->y = get_big_short(ifp, iffid, &chunksize);        /* ignored */
  667.     bmhd->nPlanes = get_byte(ifp, iffid, &chunksize);
  668.     bmhd->masking = get_byte(ifp, iffid, &chunksize);
  669.     bmhd->compression = get_byte(ifp, iffid, &chunksize);
  670.     bmhd->flags = get_byte(ifp, iffid, &chunksize);
  671.     bmhd->transparentColor = get_big_short(ifp, iffid, &chunksize);
  672.     bmhd->xAspect = get_byte(ifp, iffid, &chunksize);
  673.     bmhd->yAspect = get_byte(ifp, iffid, &chunksize);
  674.     bmhd->pageWidth  = get_big_short(ifp, iffid, &chunksize);   /* ignored */
  675.     bmhd->pageHeight = get_big_short(ifp, iffid, &chunksize);   /* ignored */
  676.  
  677.  
  678.     if( verbose ) {
  679.         if( typeid == ID_ILBM )
  680.             pm_message("dimensions: %dx%d, %d planes", bmhd->w, bmhd->h, bmhd->nPlanes);
  681.         else
  682.             pm_message("dimensions: %dx%d", bmhd->w, bmhd->h);
  683.  
  684.         if( typeid == ID_ILBM || typeid == ID_PBM ) {
  685.             pm_message("compression: %s", bmhd->compression <= cmpMAXKNOWN ?
  686.                         cmpNAME[bmhd->compression] : "unknown");
  687.  
  688.             switch( bmhd->masking ) {
  689.                 case mskNone:
  690.                     break;
  691.                 case mskHasMask:
  692.                 case mskHasTransparentColor:
  693.                     if( !maskfile )
  694.                         pm_message("use \"-maskfile <filename>\" to generate a PBM mask file from %s", mskNAME[bmhd->masking]);
  695.                     break;
  696.                 case mskLasso:
  697.                     pm_message("warning - masking type \"%s\" not supported", mskNAME[bmhd->masking]);
  698.                     break;
  699.                 default:
  700.                     pm_error("unknown masking type %d", bmhd->masking);
  701.             }
  702.         }
  703.         else    /* RGBN/RGB8 */
  704.         if( !maskfile )
  705.             pm_message("use \"-maskfile <filename>\" to generate a PBM mask file from genlock bits");
  706.     }
  707.  
  708.     /* fix aspect ratio */
  709.     if( bmhd->xAspect == 0 || bmhd->yAspect == 0 ) {
  710.         pm_message("warning - illegal aspect ratio %d:%d, using 1:1", bmhd->xAspect, bmhd->yAspect);
  711.         bmhd->xAspect = bmhd->yAspect = 1;
  712.     }
  713.  
  714.     if( bmhd->xAspect != bmhd->yAspect ) {
  715.         pm_message("warning - non-square pixels; to fix do a 'pnmscale -%cscale %g'",
  716.             bmhd->xAspect > bmhd->yAspect ? 'x' : 'y',
  717.             bmhd->xAspect > bmhd->yAspect ? (float)(bmhd->xAspect)/bmhd->yAspect : (float)(bmhd->yAspect)/bmhd->xAspect);
  718.     }
  719.  
  720.     return bmhd;
  721. }
  722.  
  723.  
  724. /****************************************************************************
  725.  Conversion functions
  726.  ****************************************************************************/
  727.  
  728. static void
  729. ham_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes)
  730.     FILE *ifp;
  731.     long chunksize;
  732.     BitMapHeader *bmhd;
  733.     ColorMap *cmap;
  734.     long viewportmodes;
  735. {
  736.     int cols, rows, hambits, hammask, hamshift, hammask2, col, row;
  737.     pixval maxval;
  738.     rawtype *rawrow;
  739.     unsigned char hamlut[256];
  740.  
  741.     cols = bmhd->w;
  742.     rows = bmhd->h;
  743.     hambits = bmhd->nPlanes - 2;
  744.     hammask = (1 << hambits) - 1;
  745.     hamshift = 8 - hambits;
  746.     hammask2 = (1 << hamshift) - 1;
  747.  
  748.     if( hambits > 8 || hambits < 1 ) {
  749.         pm_message("%d-plane HAM?? - interpreting image as a normal ILBM", bmhd->nPlanes);
  750.         viewportmodes &= ~(vmHAM);
  751.         std_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes);
  752.         return;
  753.     }
  754.  
  755.     pm_message("input is a %sHAM%d file", HAS_MULTIPALETTE(cmap) ? "multipalette " : "", bmhd->nPlanes);
  756.  
  757.     if( HAS_COLORLUT(cmap) || HAS_MONOLUT(cmap) ) {
  758.         pm_message("warning - color lookup tables ignored in HAM");
  759.         if( cmap->redlut )      free(cmap->redlut);
  760.         if( cmap->greenlut )    free(cmap->greenlut);
  761.         if( cmap->bluelut )     free(cmap->bluelut);
  762.         if( cmap->monolut )     free(cmap->monolut);
  763.         cmap->redlut = cmap->greenlut = cmap->bluelut = cmap->monolut = NULL;
  764.     }
  765.     if( !HAS_COLORMAP(cmap) ) {
  766.         pm_message("no colormap - interpreting values as grayscale");
  767.         maxval = pm_bitstomaxval(hambits);
  768.         for( col = 0; col <= maxval; col++ )
  769.             hamlut[col] = col * MAXCOLVAL / maxval;
  770.         cmap->monolut = hamlut;
  771.     }
  772.  
  773.     if( transpName ) {
  774.         transpColor = MALLOC(1, pixel);
  775.         *transpColor = ppm_parsecolor(transpName, MAXCOLVAL);
  776.     }
  777.  
  778.     if( HAS_MULTIPALETTE(cmap) )
  779.         multi_init(cmap, viewportmodes);
  780.  
  781.     rawrow = alloc_rawrow(cols);
  782.  
  783.     ppm_writeppminit(stdout, cols, rows, MAXCOLVAL, 0);
  784.     for( row = 0; row < rows; row++ ) {
  785.         pixval r, g, b;
  786.  
  787.         if( HAS_MULTIPALETTE(cmap) )
  788.             multi_update(cmap, row);
  789.  
  790.         decode_row(ifp, &chunksize, rawrow, bmhd->nPlanes, bmhd);
  791.         decode_mask(ifp, &chunksize, rawrow, bmhd);
  792.  
  793.         r = g = b = 0;
  794.         for( col = 0; col < cols; col++ ) {
  795.             int idx = rawrow[col] & hammask;
  796.  
  797.             if( transpColor && maskrow && maskrow[col] == PBM_WHITE )
  798.                 pixelrow[col] = *transpColor;
  799.             else {
  800.                 switch((rawrow[col] >> hambits) & 0x03) {
  801.                     case HAMCODE_CMAP:
  802.                         get_color(cmap, idx, &r, &g, &b);
  803.                         break;
  804.                     case HAMCODE_BLUE:
  805.                         b = ((b & hammask2) | (idx << hamshift));
  806.                         /*b = hamlut[idx];*/
  807.                         break;
  808.                     case HAMCODE_RED:
  809.                         r = ((r & hammask2) | (idx << hamshift));
  810.                         /*r = hamlut[idx];*/
  811.                         break;
  812.                     case HAMCODE_GREEN:
  813.                         g = ((g & hammask2) | (idx << hamshift));
  814.                         /*g = hamlut[idx];*/
  815.                         break;
  816.                     default:
  817.                         pm_error("ham_to_ppm(): impossible HAM code - can\'t happen");
  818.                 }
  819.                 PPM_ASSIGN(pixelrow[col], r, g, b);
  820.             }
  821.         }
  822.         ppm_writeppmrow(stdout, pixelrow, cols, MAXCOLVAL, 0);
  823.     }
  824.     chunk_end(ifp, ID_BODY, chunksize);
  825. }
  826.  
  827.  
  828. static void
  829. deep_to_ppm(ifp, chunksize, bmhd, cmap)
  830.     FILE *ifp;
  831.     long chunksize;
  832.     BitMapHeader *bmhd;
  833.     ColorMap *cmap;     /* for CLUTs */
  834. {
  835.     int cols, rows, col, row;
  836.     rawtype *Rrow, *Grow, *Brow;
  837.     int planespercolor = bmhd->nPlanes / 3;
  838.     pixval maxval;
  839.  
  840.     cols = bmhd->w;
  841.     rows = bmhd->h;
  842.  
  843.     pm_message("input is a deep (%d-bit) ILBM", bmhd->nPlanes);
  844.     if( planespercolor > MAXPLANES )
  845.         pm_error("too many planes (max %d)", MAXPLANES * 3);
  846.  
  847.     if( bmhd->masking == mskHasTransparentColor || bmhd->masking == mskLasso ) {
  848.         pm_message("masking type \"%s\" in a deep ILBM?? - ignoring it", mskNAME[bmhd->masking]);
  849.         bmhd->masking = mskNone;
  850.     }
  851.  
  852.     maxval = lut_maxval(cmap, pm_bitstomaxval(planespercolor));
  853.     if( maxval > PPM_MAXMAXVAL )
  854.         pm_error("nPlanes is too large - try reconfiguring with PGM_BIGGRAYS\n    or without PPM_PACKCOLORS" );
  855.  
  856.     if( transpName ) {
  857.         transpColor = MALLOC(1, pixel);
  858.         *transpColor = ppm_parsecolor(transpName, maxval);
  859.     }
  860.  
  861.     Rrow = alloc_rawrow(cols);
  862.     Grow = alloc_rawrow(cols);
  863.     Brow = alloc_rawrow(cols);
  864.  
  865.     ppm_writeppminit(stdout, cols, rows, maxval, 0);
  866.     for( row = 0; row < rows; row++ ) {
  867.         decode_row(ifp, &chunksize, Rrow, planespercolor, bmhd);
  868.         decode_row(ifp, &chunksize, Grow, planespercolor, bmhd);
  869.         decode_row(ifp, &chunksize, Brow, planespercolor, bmhd);
  870.         decode_mask(ifp, &chunksize, NULL, bmhd);
  871.  
  872.         for( col = 0; col < cols; col++ ) {
  873.             if( transpColor && maskrow && maskrow[col] == PBM_WHITE )
  874.                 pixelrow[col] = *transpColor;
  875.             else
  876.                 PPM_ASSIGN(pixelrow[col],   lookup_red(cmap, Rrow[col]),
  877.                                             lookup_green(cmap, Grow[col]),
  878.                                             lookup_blue(cmap, Brow[col]) );
  879.         }
  880.         ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0);
  881.     }
  882.     chunk_end(ifp, ID_BODY, chunksize);
  883. }
  884.  
  885.  
  886. static void
  887. dcol_to_ppm(ifp, chunksize, bmhd, cmap, dcol)
  888.     FILE *ifp;
  889.     long chunksize;
  890.     BitMapHeader *bmhd;
  891.     ColorMap *cmap;     /* for CLUTs */
  892.     DirectColor *dcol;
  893. {
  894.     int cols, rows, col, row, redplanes, greenplanes, blueplanes, i;
  895.     rawtype *Rrow, *Grow, *Brow;
  896.     pixval maxval, redmaxval, greenmaxval, bluemaxval;
  897.     pixval *redtable, *greentable, *bluetable;
  898.  
  899.     cols = bmhd->w;
  900.     rows = bmhd->h;
  901.  
  902.     redplanes = dcol->r; greenplanes = dcol->g; blueplanes = dcol->b;
  903.  
  904.     pm_message("input is a %d:%d:%d direct color ILBM",
  905.                 redplanes, greenplanes, blueplanes);
  906.  
  907.     if( redplanes > MAXPLANES || blueplanes > MAXPLANES || greenplanes > MAXPLANES )
  908.         pm_error("too many planes (max %d per color component)", MAXPLANES);
  909.  
  910.     if( bmhd->nPlanes != (redplanes + greenplanes + blueplanes) )
  911.         pm_error("%s/%s plane number mismatch", ID2string(ID_BMHD), ID2string(ID_DCOL));
  912.  
  913.     if( bmhd->masking == mskHasTransparentColor || bmhd->masking == mskLasso ) {
  914.         pm_message("masking type \"%s\" in a direct color ILBM?? - ignoring it", mskNAME[bmhd->masking]);
  915.         bmhd->masking = mskNone;
  916.     }
  917.  
  918.     if( HAS_COLORLUT(cmap) ) {      /* TODO */
  919.         pm_error("%s chunk not supported in direct color", ID2string(ID_CLUT));
  920.         cmap->redlut = cmap->greenlut = cmap->bluelut = NULL;
  921.     }
  922.  
  923.     redmaxval   = pm_bitstomaxval(redplanes);
  924.     greenmaxval = pm_bitstomaxval(greenplanes);
  925.     bluemaxval  = pm_bitstomaxval(blueplanes);
  926.     maxval = max(redmaxval, max(greenmaxval, bluemaxval));
  927.  
  928.     if( maxval > PPM_MAXMAXVAL )
  929.         pm_error("too many planes - try reconfiguring with PGM_BIGGRAYS\n    or without PPM_PACKCOLORS" );
  930.  
  931.     if( redmaxval != maxval || greenmaxval != maxval || bluemaxval != maxval )
  932.         pm_message("scaling colors to %d bits", pm_maxvaltobits(maxval));
  933.  
  934.     redtable   = MALLOC(redmaxval  +1, pixval);
  935.     greentable = MALLOC(greenmaxval+1, pixval);
  936.     bluetable  = MALLOC(bluemaxval +1, pixval);
  937.  
  938.     for( i = 0; i <= redmaxval; i++ )
  939.         redtable[i] = (i * maxval + redmaxval/2)/redmaxval;
  940.     for( i = 0; i <= greenmaxval; i++ )
  941.         greentable[i] = (i * maxval + greenmaxval/2)/greenmaxval;
  942.     for( i = 0; i <= bluemaxval; i++ )
  943.         bluetable[i] = (i * maxval + bluemaxval/2)/bluemaxval;
  944.  
  945.     if( transpName ) {
  946.         transpColor = MALLOC(1, pixel);
  947.         *transpColor = ppm_parsecolor(transpName, maxval);
  948.     }
  949.  
  950.     Rrow = alloc_rawrow(cols);
  951.     Grow = alloc_rawrow(cols);
  952.     Brow = alloc_rawrow(cols);
  953.  
  954.     ppm_writeppminit(stdout, cols, rows, maxval, 0);
  955.     for( row = 0; row < rows; row++ ) {
  956.         decode_row(ifp, &chunksize, Rrow, redplanes, bmhd);
  957.         decode_row(ifp, &chunksize, Grow, greenplanes, bmhd);
  958.         decode_row(ifp, &chunksize, Brow, blueplanes, bmhd);
  959.         decode_mask(ifp, &chunksize, NULL, bmhd);
  960.  
  961.         for( col = 0; col < cols; col++ ) {
  962.             if( transpColor && maskrow && maskrow[col] == PBM_WHITE )
  963.                 pixelrow[col] = *transpColor;
  964.             else
  965.                 PPM_ASSIGN( pixelrow[col],  redtable[Rrow[col]],
  966.                                             greentable[Grow[col]],
  967.                                             bluetable[Brow[col]]   );
  968.         }
  969.         ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0);
  970.     }
  971.     chunk_end(ifp, ID_BODY, chunksize);
  972. }
  973.  
  974.  
  975. static void
  976. cmap_to_ppm(cmap)
  977.     ColorMap *cmap;
  978. {
  979.     ppm_colorrowtomapfile(stdout, cmap->color, cmap->ncolors, MAXCOLVAL);
  980. #if 0
  981.     int i;
  982.     ppm_writeppminit(stdout, cmap->ncolors, 1, MAXCOLVAL, 1);
  983.     for( i = 0; i < cmap->ncolors; i++ )
  984.         ppm_writeppmrow(stdout, &(cmap->color[i]), 1, MAXCOLVAL, 1);
  985. #endif
  986. }
  987.  
  988.  
  989. static void
  990. std_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes)
  991.     FILE *ifp;
  992.     long chunksize;
  993.     BitMapHeader *bmhd;
  994.     ColorMap *cmap;
  995.     long viewportmodes;
  996. {
  997.     rawtype *rawrow;
  998.     int row, rows, col, cols;
  999.     pixval maxval;
  1000.  
  1001.     if( viewportmodes & vmHAM ) {
  1002.         ham_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes);
  1003.         return;
  1004.     }
  1005.  
  1006.     cols = bmhd->w;
  1007.     rows = bmhd->h;
  1008.  
  1009.     pm_message("input is a %d-plane %s%sILBM", bmhd->nPlanes,
  1010.                 HAS_MULTIPALETTE(cmap) ? "multipalette " : "",
  1011.                 viewportmodes & vmEXTRA_HALFBRITE ? "EHB " : ""
  1012.               );
  1013.  
  1014.     if( bmhd->nPlanes > MAXPLANES )
  1015.         pm_error("too many planes (max %d)", MAXPLANES);
  1016.  
  1017.     if( HAS_COLORMAP(cmap) ) {
  1018.         if( viewportmodes & vmEXTRA_HALFBRITE )
  1019.             cmap = ehbcmap(cmap);
  1020.         maxval = MAXCOLVAL;
  1021.     }
  1022.     else {
  1023.         pm_message("no colormap - interpreting values as grayscale");
  1024.         maxval = lut_maxval(cmap, pm_bitstomaxval(bmhd->nPlanes));
  1025.         if( maxval > PPM_MAXMAXVAL )
  1026.             pm_error("nPlanes is too large - try reconfiguring with PGM_BIGGRAYS\n    or without PPM_PACKCOLORS" );
  1027.     }
  1028.  
  1029.     if( transpName ) {
  1030.         transpColor = MALLOC(1, pixel);
  1031.         *transpColor = ppm_parsecolor(transpName, maxval);
  1032.     }
  1033.  
  1034.     rawrow = alloc_rawrow(cols);
  1035.  
  1036.     if( HAS_MULTIPALETTE(cmap) )
  1037.         multi_init(cmap, viewportmodes);
  1038.  
  1039.     ppm_writeppminit( stdout, cols, rows, maxval, 0 );
  1040.     for( row = 0; row < rows; row++ ) {
  1041.  
  1042.         if( HAS_MULTIPALETTE(cmap) )
  1043.             multi_update(cmap, row);
  1044.  
  1045.         decode_row(ifp, &chunksize, rawrow, bmhd->nPlanes, bmhd);
  1046.         decode_mask(ifp, &chunksize, rawrow, bmhd);
  1047.  
  1048.         for( col = 0; col < cols; col++ ) {
  1049.             pixval r, g, b;
  1050.             if( transpColor && maskrow && maskrow[col] == PBM_WHITE )
  1051.                 pixelrow[col] = *transpColor;
  1052.             else {
  1053.                 get_color(cmap, rawrow[col], &r, &g, &b);
  1054.                 PPM_ASSIGN(pixelrow[col], r, g, b);
  1055.             }
  1056.         }
  1057.         ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0);
  1058.     }
  1059.     chunk_end(ifp, ID_BODY, chunksize);
  1060. }
  1061.  
  1062.  
  1063. static void
  1064. ipbm_to_ppm(ifp, chunksize, bmhd, cmap, viewportmodes)
  1065.     FILE *ifp;
  1066.     long chunksize;
  1067.     BitMapHeader *bmhd;
  1068.     ColorMap *cmap;
  1069.     long viewportmodes;
  1070. {
  1071.     int col, cols, row, rows;
  1072.     pixval maxval;
  1073.  
  1074.     cols = bmhd->w;
  1075.     rows = bmhd->h;
  1076.  
  1077.     pm_message("input is a %sPBM ", HAS_MULTIPALETTE(cmap) ? "multipalette " : "");
  1078.  
  1079.     if( bmhd->nPlanes != 8 )
  1080.         pm_error("invalid number of planes for IFF-PBM: %d (must be 8)", bmhd->nPlanes);
  1081.  
  1082.     if( bmhd->masking == mskHasMask )
  1083.         pm_error("maskplane not supported in IFF-PBM");
  1084.  
  1085.     if( HAS_COLORMAP(cmap) )
  1086.         maxval = MAXCOLVAL;
  1087.     else {
  1088.         pm_message("no colormap - interpreting values as grayscale");
  1089.         maxval = lut_maxval(cmap, pm_bitstomaxval(bmhd->nPlanes));
  1090.     }
  1091.  
  1092.     if( transpName ) {
  1093.         transpColor = MALLOC(1, pixel);
  1094.         *transpColor = ppm_parsecolor(transpName, maxval);
  1095.     }
  1096.  
  1097.     if( HAS_MULTIPALETTE(cmap) )
  1098.         multi_init(cmap, viewportmodes);
  1099.  
  1100.     ilbmrow = MALLOC(cols, unsigned char);
  1101.  
  1102.     ppm_writeppminit(stdout, cols, rows, maxval, 0);
  1103.     for( row = 0; row < rows; row++ ) {
  1104.         if( HAS_MULTIPALETTE(cmap) )
  1105.             multi_update(cmap, row);
  1106.  
  1107.         read_ilbm_plane(ifp, &chunksize, cols, bmhd->compression);
  1108.  
  1109.         for( col = 0; col < cols; col++ ) {
  1110.             pixval r, g, b;
  1111.             if( transpColor && maskrow && maskrow[col] == PBM_WHITE )
  1112.                 pixelrow[col] = *transpColor;
  1113.             else {
  1114.                 get_color(cmap, ilbmrow[col], &r, &g, &b);
  1115.                 PPM_ASSIGN(pixelrow[col], r, g, b);
  1116.             }
  1117.         }
  1118.         ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0);
  1119.     }
  1120.     chunk_end(ifp, ID_BODY, chunksize);
  1121. }
  1122.  
  1123.  
  1124. static void
  1125. rgbn_to_ppm(ifp, chunksize, bmhd, cmap)
  1126.     FILE *ifp;
  1127.     long chunksize;
  1128.     BitMapHeader *bmhd;
  1129.     ColorMap *cmap;     /* for CLUTs */
  1130. {
  1131.     int row, rows, col, cols, count, genlock, tries;
  1132.     pixval r, g, b, maxval;
  1133.  
  1134.     pm_message("input is a %d-bit RGB image", (typeid == ID_RGB8 ? 8 : 4));
  1135.  
  1136.     rows = bmhd->h;
  1137.     cols = bmhd->w;
  1138.     if( bmhd->compression != 4 )
  1139.         pm_error("invalid compression mode for %s: %d (must be 4)", ID2string(typeid), bmhd->compression);
  1140.  
  1141.     switch( typeid ) {
  1142.         case ID_RGBN:
  1143.             if( bmhd->nPlanes != 13 )
  1144.                 pm_error("invalid number of planes for %s: %d (must be 13)", ID2string(typeid), bmhd->nPlanes);
  1145.             maxval = lut_maxval(cmap, 15);
  1146.             break;
  1147.         case ID_RGB8:
  1148.             if( bmhd->nPlanes != 25 )
  1149.                 pm_error("invalid number of planes for %s: %d (must be 25)", ID2string(typeid), bmhd->nPlanes);
  1150.             maxval = 255;
  1151.             break;
  1152.         default:
  1153.             pm_error("rgbn_to_ppm(): invalid IFF ID %s - can\'t happen", ID2string(typeid));
  1154.     }
  1155.  
  1156.     if( transpName ) {
  1157.         transpColor = MALLOC(1, pixel);
  1158.         *transpColor = ppm_parsecolor(transpName, maxval);
  1159.     }
  1160.  
  1161.     ppm_writeppminit(stdout, cols, rows, maxval, 0);
  1162.     count = 0;
  1163.     for( row = 0; row < rows; row++ ) {
  1164.         for( col = 0; col < cols; col++ ) {
  1165.             tries = 0;
  1166.             while( !count ) {
  1167.                 if( typeid == ID_RGB8 ) {
  1168.                     r = lookup_red(cmap,   get_byte(ifp, ID_BODY, &chunksize));
  1169.                     g = lookup_green(cmap, get_byte(ifp, ID_BODY, &chunksize));
  1170.                     b = lookup_blue(cmap,  get_byte(ifp, ID_BODY, &chunksize));
  1171.                     count = get_byte(ifp, ID_BODY, &chunksize);
  1172.                     genlock = count & 0x80;
  1173.                     count &= 0x7f;
  1174.                 }
  1175.                 else {
  1176.                     int word;
  1177.                     word = get_big_short(ifp, ID_BODY, &chunksize);
  1178.                     r = lookup_red(cmap, (word & 0xf000) >> 12);
  1179.                     g = lookup_green(cmap, (word & 0x0f00) >> 8);
  1180.                     b = lookup_blue(cmap, (word & 0x00f0) >> 4);
  1181.                     genlock = word & 0x0008;
  1182.                     count = word & 0x0007;
  1183.                 }
  1184.                 if( !count ) {
  1185.                     count = get_byte(ifp, ID_BODY, &chunksize);
  1186.                     if( !count )
  1187.                         count = get_big_short(ifp, ID_BODY, &chunksize);
  1188.                         if( !count )
  1189.                             ++tries;
  1190.                 }
  1191.             }
  1192.             if( tries ) {
  1193.                 pm_message("warning - repeat count 0 at col %d row %d: skipped %d RGB entr%s",
  1194.                             col, row, tries, (tries == 1 ? "y" : "ies"));
  1195.             }
  1196.             if( maskfile ) {
  1197.                 /* genlock bit set -> transparent */
  1198.                 if( genlock )
  1199.                     maskrow[col] = PBM_WHITE;
  1200.                 else
  1201.                     maskrow[col] = PBM_BLACK;
  1202.             }
  1203.             if( transpColor && maskrow && maskrow[col] == PBM_WHITE )
  1204.                 pixelrow[col] = *transpColor;
  1205.             else
  1206.                 PPM_ASSIGN(pixelrow[col], r, g, b);
  1207.             --count;
  1208.         }
  1209.         ppm_writeppmrow(stdout, pixelrow, cols, maxval, 0);
  1210.         if( maskfile ) {
  1211.             pbm_writepbmrow(maskfile, maskrow, cols, 0);
  1212.             wrotemask = 1;
  1213.         }
  1214.     }
  1215.     chunk_end(ifp, ID_BODY, chunksize);
  1216. }
  1217.  
  1218. /****************************************************************************
  1219.  ILBM functions
  1220.  ****************************************************************************/
  1221.  
  1222.  
  1223. static void
  1224. read_ilbm_plane(ifp, chunksizeP, bytes, compression)
  1225.     FILE *ifp;
  1226.     long *chunksizeP;
  1227.     int bytes, compression;
  1228. {
  1229.     unsigned char *ubp;
  1230.     int j, byte;
  1231.  
  1232.     switch(compression) {
  1233.         case cmpNone:
  1234.             read_bytes(ifp, bytes, ilbmrow, ID_BODY, chunksizeP);
  1235.             break;
  1236.         case cmpByteRun1:
  1237.             ubp = ilbmrow;
  1238.             do {
  1239.                 byte = (int)get_byte(ifp, ID_BODY, chunksizeP);
  1240.                 if( byte <= 127 ) {
  1241.                     j = byte;
  1242.                     bytes -= (j+1);
  1243.                     if( bytes < 0 )
  1244.                         pm_error("error doing ByteRun1 decompression");
  1245.                     for( ; j >= 0; j-- )
  1246.                         *ubp++ = get_byte(ifp, ID_BODY, chunksizeP);
  1247.                 }
  1248.                 else
  1249.                 if ( byte != 128 ) {
  1250.                     j = 256 - byte;
  1251.                     bytes -= (j+1);
  1252.                     if( bytes < 0 )
  1253.                         pm_error("error doing ByteRun1 decompression");
  1254.                     byte = (int)get_byte(ifp, ID_BODY, chunksizeP);
  1255.                     for( ; j >= 0; j-- )
  1256.                         *ubp++ = (unsigned char)byte;
  1257.                 }
  1258.                 /* 128 is a NOP */
  1259.             }
  1260.             while( bytes > 0 );
  1261.             break;
  1262.         default:
  1263.             pm_error("unknown compression type %d", compression);
  1264.     }
  1265. }
  1266.  
  1267.  
  1268. static const unsigned char bit_mask[] = {1, 2, 4, 8, 16, 32, 64, 128};
  1269.  
  1270. static void
  1271. decode_row(ifp, chunksizeP, chunkyrow, nPlanes, bmhd)
  1272.     FILE *ifp;
  1273.     long *chunksizeP;
  1274.     rawtype *chunkyrow;
  1275.     int nPlanes;
  1276.     BitMapHeader *bmhd;
  1277. {
  1278.     int plane, col, cols, cbit, bytes;
  1279.     unsigned char *ilp;
  1280.     rawtype *chp;
  1281.  
  1282.     cols = bmhd->w;
  1283.     bytes = RowBytes(cols);
  1284.     for( plane = 0; plane < nPlanes; plane++ ) {
  1285.         int mask;
  1286.  
  1287.         mask = 1 << plane;
  1288.         read_ilbm_plane(ifp, chunksizeP, bytes, bmhd->compression);
  1289.  
  1290.         ilp = ilbmrow;
  1291.         chp = chunkyrow;
  1292.  
  1293.         cbit = 7;
  1294.         for( col = 0; col < cols; col++, cbit--, chp++ ) {
  1295.             if( cbit < 0 ) {
  1296.                 cbit = 7;
  1297.                 ilp++;
  1298.             }
  1299.             if( *ilp & bit_mask[cbit] )
  1300.                 *chp |= mask;
  1301.             else
  1302.                 *chp &= ~mask;
  1303.         }
  1304.     }
  1305. }
  1306.  
  1307.  
  1308. static void
  1309. decode_mask(ifp, chunksizeP, chunkyrow, bmhd)
  1310.     FILE *ifp;
  1311.     long *chunksizeP;
  1312.     rawtype *chunkyrow;
  1313.     BitMapHeader *bmhd;
  1314. {
  1315.     int col, cols, cbit;
  1316.     unsigned char *ilp;
  1317.  
  1318.     cols = bmhd->w;
  1319.     switch( bmhd->masking ) {
  1320.         case mskNone:
  1321.             break;
  1322.         case mskHasMask:        /* mask plane */
  1323.             read_ilbm_plane(ifp, chunksizeP, RowBytes(cols), bmhd->compression);
  1324.             if( maskfile ) {
  1325.                 ilp = ilbmrow;
  1326.                 cbit = 7;
  1327.                 for( col = 0; col < cols; col++, cbit-- ) {
  1328.                     if( cbit < 0 ) {
  1329.                         cbit = 7;
  1330.                         ilp++;
  1331.                     }
  1332.                     if( *ilp & bit_mask[cbit] )
  1333.                         maskrow[col] = PBM_BLACK;
  1334.                     else
  1335.                         maskrow[col] = PBM_WHITE;
  1336.                 }
  1337.                 pbm_writepbmrow(maskfile, maskrow, cols, 0);
  1338.                 wrotemask = 1;
  1339.             }
  1340.             break;
  1341.         case mskHasTransparentColor:
  1342.             if( !chunkyrow )
  1343.                 pm_error("decode_mask(): chunkyrow == NULL - can\'t happen");
  1344.  
  1345.             if( maskfile ) {
  1346.                 for( col = 0; col < cols; col++ ) {
  1347.                     if( chunkyrow[col] == bmhd->transparentColor )
  1348.                         maskrow[col] = PBM_WHITE;
  1349.                     else
  1350.                         maskrow[col] = PBM_BLACK;
  1351.                 }
  1352.                 pbm_writepbmrow(maskfile, maskrow, cols, 0);
  1353.                 wrotemask = 1;
  1354.             }
  1355.             break;
  1356.         case mskLasso:
  1357.             /* not supported yet */
  1358.             break;
  1359.         default:
  1360.             pm_error("decode_mask(): unknown masking type %d - can\'t happen", bmhd->masking);
  1361.     }
  1362. }
  1363.  
  1364.  
  1365. static rawtype *
  1366. alloc_rawrow(cols)
  1367.     int cols;
  1368. {
  1369.     rawtype *r;
  1370.     int i;
  1371.  
  1372.     r = MALLOC(cols, rawtype);
  1373.  
  1374.     for( i = 0; i < cols; i++ )
  1375.         r[i] = 0;
  1376.  
  1377.     return r;
  1378. }
  1379.  
  1380.  
  1381. static void *
  1382. xmalloc(bytes)
  1383.     int bytes;
  1384. {
  1385.     void *mem;
  1386.  
  1387.     if( bytes == 0 )
  1388.         return NULL;
  1389.  
  1390.     mem = malloc(bytes);
  1391.     if( mem == NULL )
  1392.         pm_error("out of memory allocating %d bytes", bytes);
  1393.     return mem;
  1394. }
  1395.  
  1396.  
  1397. static char *
  1398. ID2string(id)
  1399.     IFF_ID id;
  1400. {
  1401.     static char str[] = "abcd";
  1402.  
  1403.     str[0] = (char)(id >> 24 & 0xff);
  1404.     str[1] = (char)(id >> 16 & 0xff);
  1405.     str[2] = (char)(id >>  8 & 0xff);
  1406.     str[3] = (char)(id >>  0 & 0xff);
  1407.  
  1408.     return str;
  1409. }
  1410.  
  1411.  
  1412. /****************************************************************************
  1413.  Multipalette chunk reader
  1414.  
  1415.     Currently there are three multipalette formats:
  1416.         SHAM - sliced HAM (obselete)
  1417.         CTBL - dynamic HAM/Hires (obselete)
  1418.         PCHG - palette change
  1419.     There is no official documentation available for SHAM and CTBL, so
  1420.    this is mostly guesswork from other sources and hexdumps of pictures...
  1421.  
  1422.     CTBL format (dynamic HAM/Hires):
  1423.         16 bigendian words per row (16 bit: 0000rrrrggggbbbb)
  1424.     This is simply an entire 4-bit colormap per row.
  1425.     I have no idea what the DYCP chunk is for.
  1426.  
  1427.     SHAM format (sliced HAM):
  1428.         1 word  - version info (?) - always 0
  1429.         16 bigendian words per row (16 bit: 0000rrrrggggbbbb)
  1430.     If the picture is laced, then there are only rows/2 changes, don't change
  1431.     palette on odd lines.
  1432.  
  1433.     PCHG format:
  1434.     A detailed description of this format is available from AmiNet as PCHGLib12.lha.
  1435.  
  1436.  ****************************************************************************/
  1437.  
  1438. /* local functions */
  1439. static void PCHG_Decompress ARGS((PCHGHeader *PCHG, PCHGCompHeader *CompHdr, unsigned char *compdata, unsigned long compsize, unsigned char *comptree, unsigned char *data));
  1440. static void PCHG_DecompHuff ARGS((unsigned char *src, unsigned char *dest, short *tree, unsigned long origsize));
  1441. static void PCHG_ConvertSmall ARGS((PCHGHeader *PCHG, ColorMap *cmap, unsigned char *data, unsigned long datasize));
  1442. static void PCHG_ConvertBig   ARGS((PCHGHeader *PCHG, ColorMap *cmap, unsigned char *data, unsigned long datasize));
  1443. static void multi_adjust ARGS((ColorMap *cmap, int row, PaletteChange *palchange));
  1444. /* Turn big-endian 4-byte long and 2-byte short stored at x (unsigned char *)
  1445.  * into the native format of the CPU
  1446.  */
  1447. #define BIG_LONG(x) (   ((unsigned long)((x)[0]) << 24) + \
  1448.                         ((unsigned long)((x)[1]) << 16) + \
  1449.                         ((unsigned long)((x)[2]) <<  8) + \
  1450.                         ((unsigned long)((x)[3]) <<  0) )
  1451. #define BIG_WORD(x) (   ((unsigned short)((x)[0]) << 8) + \
  1452.                         ((unsigned short)((x)[1]) << 0) )
  1453.  
  1454.  
  1455.  
  1456. static ColorMap *
  1457. read_4bit_mp(ifp, iffid, chunksize, cmap)
  1458.     FILE *ifp;
  1459.     IFF_ID iffid;
  1460.     long chunksize;
  1461.     ColorMap *cmap;
  1462. {
  1463.     int row, rows, i, type;
  1464.     short data;
  1465.  
  1466.     if( !cmap )
  1467.         cmap = alloc_cmap();
  1468.  
  1469.     type = (iffid == ID_SHAM ? MP_TYPE_SHAM : MP_TYPE_CTBL);
  1470.  
  1471.     if( cmap->mp_type >= type ) {
  1472.         skip_chunk(ifp, iffid, chunksize);
  1473.         return cmap;
  1474.     }
  1475.     if( cmap->mp_type )
  1476.         multi_free(cmap);
  1477.     cmap->mp_type = type;
  1478.  
  1479.     if( type == MP_TYPE_SHAM ) {
  1480.         cmap->mp_flags = MP_FLAGS_SKIPLACED;
  1481.         (void)get_big_short(ifp, iffid, &chunksize);   /* skip first word */
  1482.     }
  1483.  
  1484.     cmap->mp_rows = rows = chunksize/32;    /* sizeof(word) * 16 */
  1485.     cmap->mp_change = MALLOC(rows, PaletteChange *);
  1486.  
  1487.     for( row = 0; row < rows; row++ ) {
  1488.         cmap->mp_change[row] = MALLOC(17, PaletteChange);   /* 16 + sentinel */
  1489.         for( i = 0; i < 16; i++ ) {
  1490.             data = get_big_short(ifp, iffid, &chunksize);
  1491.             cmap->mp_change[row][i].reg = i;
  1492.             cmap->mp_change[row][i].r = ((data & 0x0f00) >> 8) * FACTOR_4BIT;
  1493.             cmap->mp_change[row][i].g = ((data & 0x00f0) >> 4) * FACTOR_4BIT;
  1494.             cmap->mp_change[row][i].b = ((data & 0x000f) >> 0) * FACTOR_4BIT;
  1495.         }
  1496.         cmap->mp_change[row][16].reg = MP_REG_END;   /* sentinel */
  1497.     }
  1498.     chunk_end(ifp, iffid, chunksize);
  1499.     return cmap;
  1500. }
  1501.  
  1502.  
  1503. static ColorMap *
  1504. read_pchg(ifp, iffid, chunksize, cmap)
  1505.     FILE *ifp;
  1506.     IFF_ID iffid;
  1507.     long chunksize;
  1508.     ColorMap *cmap;
  1509. {
  1510.     PCHGHeader      PCHG;
  1511.     unsigned char   *data;
  1512.     unsigned long   datasize;
  1513.     int i;
  1514.  
  1515.     if( !cmap )
  1516.         cmap = alloc_cmap();
  1517.  
  1518.     if( cmap->mp_type >= MP_TYPE_PCHG ) {
  1519.         skip_chunk(ifp, iffid, chunksize);
  1520.         return cmap;
  1521.     }
  1522.     if( cmap->mp_type )
  1523.         multi_free(cmap);
  1524.     cmap->mp_type = MP_TYPE_PCHG;
  1525.  
  1526.     PCHG.Compression = get_big_short(ifp, iffid, &chunksize);
  1527.     PCHG.Flags       = get_big_short(ifp, iffid, &chunksize);
  1528.     PCHG.StartLine   = get_big_short(ifp, iffid, &chunksize);
  1529.     PCHG.LineCount   = get_big_short(ifp, iffid, &chunksize);
  1530.     PCHG.ChangedLines= get_big_short(ifp, iffid, &chunksize);
  1531.     PCHG.MinReg      = get_big_short(ifp, iffid, &chunksize);
  1532.     PCHG.MaxReg      = get_big_short(ifp, iffid, &chunksize);
  1533.     PCHG.MaxChanges  = get_big_short(ifp, iffid, &chunksize);
  1534.     PCHG.TotalChanges= get_big_long(ifp, iffid, &chunksize);
  1535.  
  1536. #ifdef DEBUG
  1537.     pm_message("PCHG StartLine   : %d", PCHG.StartLine);
  1538.     pm_message("PCHG LineCount   : %d", PCHG.LineCount);
  1539.     pm_message("PCHG ChangedLines: %d", PCHG.ChangedLines);
  1540.     pm_message("PCHG TotalChanges: %d", PCHG.TotalChanges);
  1541. #endif
  1542.  
  1543.     if( PCHG.Compression != PCHG_COMP_NONE ) {
  1544.         PCHGCompHeader  CompHdr;
  1545.         unsigned char *compdata, *comptree;
  1546.         long treesize, compsize;
  1547.  
  1548.         CompHdr.CompInfoSize     = get_big_long(ifp, iffid, &chunksize);
  1549.         CompHdr.OriginalDataSize = get_big_long(ifp, iffid, &chunksize);
  1550.  
  1551.         treesize = CompHdr.CompInfoSize;
  1552.         comptree = MALLOC(treesize, unsigned char);
  1553.         read_bytes(ifp, treesize, comptree, iffid, &chunksize);
  1554.  
  1555.         compsize = chunksize;
  1556.         compdata= MALLOC(chunksize, unsigned char);
  1557.         read_bytes(ifp, compsize, compdata, iffid, &chunksize);
  1558.  
  1559.         datasize = CompHdr.OriginalDataSize;
  1560.         data    = MALLOC(datasize, unsigned char);
  1561.         PCHG_Decompress(&PCHG, &CompHdr, compdata, compsize, comptree, data);
  1562.  
  1563.         free(comptree);
  1564.         free(compdata);
  1565.     }
  1566.     else {
  1567. #ifdef DEBUG
  1568.         pm_message("uncompressed PCHG");
  1569. #endif
  1570.         datasize = chunksize;
  1571.         data = MALLOC(datasize, unsigned char);
  1572.         read_bytes(ifp, datasize, data, iffid, &chunksize);
  1573.     }
  1574.  
  1575.     if( PCHG.Flags & PCHGF_USE_ALPHA )
  1576.         pm_message("warning - PCHG alpha channel not supported");
  1577.  
  1578.     cmap->mp_rows = PCHG.StartLine + PCHG.LineCount;
  1579.     cmap->mp_change = MALLOC(cmap->mp_rows, PaletteChange *);
  1580.     for( i = 0; i < cmap->mp_rows; i++ )
  1581.         cmap->mp_change[i] = NULL;
  1582.     if( PCHG.StartLine < 0 ) {
  1583.         int nch;
  1584.         nch = PCHG.MaxReg - PCHG.MinReg +1;
  1585.         cmap->mp_init = MALLOC(nch + 1, PaletteChange);
  1586.         for( i = 0; i < nch; i++ )
  1587.             cmap->mp_init[i].reg = MP_REG_IGNORE;
  1588.         cmap->mp_init[nch].reg = MP_REG_END;
  1589.     }
  1590.  
  1591.     if( PCHG.Flags & PCHGF_12BIT ) {
  1592. #ifdef DEBUG
  1593.         pm_message("SmallLineChanges");
  1594. #endif
  1595.         PCHG_ConvertSmall(&PCHG, cmap, data, datasize);
  1596.     }
  1597.     else
  1598.     if( PCHG.Flags & PCHGF_32BIT ) {
  1599. #ifdef DEBUG
  1600.         pm_message("BigLineChanges");
  1601. #endif
  1602.         PCHG_ConvertBig(&PCHG, cmap, data, datasize);
  1603.     }
  1604.     else
  1605.         pm_error("unknown palette changes structure format in %s chunk", ID2string(iffid));
  1606.  
  1607.     free(data);
  1608.     chunk_end(ifp, iffid, chunksize);
  1609.     return cmap;
  1610. }
  1611.  
  1612.  
  1613. static void
  1614. PCHG_Decompress(PCHG, CompHdr, compdata, compsize, comptree, data)
  1615.     PCHGHeader *PCHG;
  1616.     PCHGCompHeader *CompHdr;
  1617.     unsigned char *compdata;
  1618.     unsigned long compsize;
  1619.     unsigned char *comptree;
  1620.     unsigned char *data;
  1621. {
  1622.     short *hufftree;
  1623.     unsigned long huffsize, i;
  1624.     unsigned long treesize = CompHdr->CompInfoSize;
  1625.  
  1626.     switch( PCHG->Compression ) {
  1627.         case PCHG_COMP_HUFFMAN:
  1628.  
  1629. #ifdef DEBUG
  1630.             pm_message("PCHG Huffman compression");
  1631. #endif
  1632.             /* turn big-endian 2-byte shorts into native format */
  1633.             huffsize = treesize/2;
  1634.             hufftree = MALLOC(huffsize, short);
  1635.             for( i = 0; i < huffsize; i++ ) {
  1636.                 hufftree[i] = (short)BIG_WORD(comptree);
  1637.                 comptree += 2;
  1638.             }
  1639.  
  1640.             /* decompress the change structure data */
  1641.             PCHG_DecompHuff(compdata, data, &hufftree[huffsize-1], CompHdr->OriginalDataSize);
  1642.  
  1643.             free(hufftree);
  1644.             break;
  1645.         default:
  1646.             pm_error("unknown PCHG compression type %d", PCHG->Compression);
  1647.     }
  1648. }
  1649.  
  1650.  
  1651. static void
  1652. PCHG_ConvertSmall(PCHG, cmap, mask, datasize)
  1653.     PCHGHeader *PCHG;
  1654.     ColorMap *cmap;
  1655.     unsigned char *mask;
  1656.     unsigned long datasize;
  1657. {
  1658.     unsigned char *data;
  1659.     unsigned char thismask;
  1660.     int bits, row, i, changes, masklen, reg;
  1661.     unsigned char ChangeCount16, ChangeCount32;
  1662.     unsigned short SmallChange;
  1663.     unsigned long totalchanges = 0;
  1664.     int changedlines = PCHG->ChangedLines;
  1665.  
  1666.     masklen = 4 * MaskLongWords(PCHG->LineCount);
  1667.     data = mask + masklen; datasize -= masklen;
  1668.  
  1669.     bits = 0;
  1670.     for( row = PCHG->StartLine; changedlines && row < 0; row++ ) {
  1671.         if( bits == 0 ) {
  1672.             if( masklen == 0 ) goto fail2;
  1673.             thismask = *mask++;
  1674.             --masklen;
  1675.             bits = 8;
  1676.         }
  1677.         if( thismask & (1<<7) ) {
  1678.             if( datasize < 2 ) goto fail;
  1679.             ChangeCount16 = *data++;
  1680.             ChangeCount32 = *data++;
  1681.             datasize -= 2;
  1682.  
  1683.             changes = ChangeCount16 + ChangeCount32;
  1684.             for( i = 0; i < changes; i++ ) {
  1685.                 if( totalchanges >= PCHG->TotalChanges ) goto fail;
  1686.                 if( datasize < 2 ) goto fail;
  1687.                 SmallChange = BIG_WORD(data); data += 2; datasize -= 2;
  1688.                 reg = ((SmallChange & 0xf000) >> 12) + (i >= ChangeCount16 ? 16 : 0);
  1689.                 cmap->mp_init[reg - PCHG->MinReg].reg = reg;
  1690.                 cmap->mp_init[reg - PCHG->MinReg].r = ((SmallChange & 0x0f00) >> 8) * FACTOR_4BIT;
  1691.                 cmap->mp_init[reg - PCHG->MinReg].g = ((SmallChange & 0x00f0) >> 4) * FACTOR_4BIT;
  1692.                 cmap->mp_init[reg - PCHG->MinReg].b = ((SmallChange & 0x000f) >> 0) * FACTOR_4BIT;
  1693.                 ++totalchanges;
  1694.             }
  1695.             --changedlines;
  1696.         }
  1697.         thismask <<= 1;
  1698.         bits--;
  1699.     }
  1700.  
  1701.     for( row = PCHG->StartLine; changedlines && row < cmap->mp_rows; row++ ) {
  1702.         if( bits == 0 ) {
  1703.             if( masklen == 0 ) goto fail2;
  1704.             thismask = *mask++;
  1705.             --masklen;
  1706.             bits = 8;
  1707.         }
  1708.         if( thismask & (1<<7) ) {
  1709.             if( datasize < 2 ) goto fail;
  1710.             ChangeCount16 = *data++;
  1711.             ChangeCount32 = *data++;
  1712.             datasize -= 2;
  1713.  
  1714.             changes = ChangeCount16 + ChangeCount32;
  1715.             cmap->mp_change[row] = MALLOC(changes + 1, PaletteChange);
  1716.             for( i = 0; i < changes; i++ ) {
  1717.                 if( totalchanges >= PCHG->TotalChanges ) goto fail;
  1718.                 if( datasize < 2 ) goto fail;
  1719.                 SmallChange = BIG_WORD(data); data += 2; datasize -= 2;
  1720.                 reg = ((SmallChange & 0xf000) >> 12) + (i >= ChangeCount16 ? 16 : 0);
  1721.                 cmap->mp_change[row][i].reg = reg;
  1722.                 cmap->mp_change[row][i].r = ((SmallChange & 0x0f00) >> 8) * FACTOR_4BIT;
  1723.                 cmap->mp_change[row][i].g = ((SmallChange & 0x00f0) >> 4) * FACTOR_4BIT;
  1724.                 cmap->mp_change[row][i].b = ((SmallChange & 0x000f) >> 0) * FACTOR_4BIT;
  1725.                 ++totalchanges;
  1726.             }
  1727.             cmap->mp_change[row][changes].reg = MP_REG_END;
  1728.             --changedlines;
  1729.         }
  1730.         thismask <<= 1;
  1731.         bits--;
  1732.     }
  1733.     if( totalchanges != PCHG->TotalChanges )
  1734.         pm_message("warning - got %ld change structures, chunk header reports %ld", totalchanges, PCHG->TotalChanges);
  1735.     return;
  1736. fail:
  1737.     pm_error("insufficient data in SmallLineChanges structures");
  1738. fail2:
  1739.     pm_error("insufficient data in line mask");
  1740. }
  1741.  
  1742.  
  1743. static void
  1744. PCHG_ConvertBig(PCHG, cmap, mask, datasize)
  1745.     PCHGHeader *PCHG;
  1746.     ColorMap *cmap;
  1747.     unsigned char *mask;
  1748.     unsigned long datasize;
  1749. {
  1750.     unsigned char *data;
  1751.     unsigned char thismask;
  1752.     int bits, row, i, changes, masklen, reg;
  1753.     unsigned long totalchanges = 0;
  1754.     int changedlines = PCHG->ChangedLines;
  1755.  
  1756.     masklen = 4 * MaskLongWords(PCHG->LineCount);
  1757.     data = mask + masklen; datasize -= masklen;
  1758.  
  1759.     bits = 0;
  1760.     for( row = PCHG->StartLine; changedlines && row < 0; row++ ) {
  1761.         if( bits == 0 ) {
  1762.             if( masklen == 0 ) goto fail2;
  1763.             thismask = *mask++;
  1764.             --masklen;
  1765.             bits = 8;
  1766.         }
  1767.         if( thismask & (1<<7) ) {
  1768.             if( datasize < 2 ) goto fail;
  1769.             changes = BIG_WORD(data); data += 2; datasize -= 2;
  1770.  
  1771.             for( i = 0; i < changes; i++ ) {
  1772.                 if( totalchanges >= PCHG->TotalChanges ) goto fail;
  1773.                 if( datasize < 6 ) goto fail;
  1774.                 reg = BIG_WORD(data); data += 2;
  1775.                 cmap->mp_init[reg - PCHG->MinReg].reg = reg;
  1776.                 ++data; /* skip alpha */
  1777.                 cmap->mp_init[reg - PCHG->MinReg].r = *data++;
  1778.                 cmap->mp_init[reg - PCHG->MinReg].b = *data++;    /* yes, RBG */
  1779.                 cmap->mp_init[reg - PCHG->MinReg].g = *data++;
  1780.                 datasize -= 6;
  1781.                 ++totalchanges;
  1782.             }
  1783.             --changedlines;
  1784.         }
  1785.         thismask <<= 1;
  1786.         bits--;
  1787.     }
  1788.  
  1789.     for( row = PCHG->StartLine; changedlines && row < cmap->mp_rows; row++ ) {
  1790.         if( bits == 0 ) {
  1791.             if( masklen == 0 ) goto fail2;
  1792.             thismask = *mask++;
  1793.             --masklen;
  1794.             bits = 8;
  1795.         }
  1796.         if( thismask & (1<<7) ) {
  1797.             if( datasize < 2 ) goto fail;
  1798.             changes = BIG_WORD(data); data += 2; datasize -= 2;
  1799.  
  1800.             cmap->mp_change[row] = MALLOC(changes + 1, PaletteChange);
  1801.             for( i = 0; i < changes; i++ ) {
  1802.                 if( totalchanges >= PCHG->TotalChanges ) goto fail;
  1803.                 if( datasize < 6 ) goto fail;
  1804.                 reg = BIG_WORD(data); data += 2;
  1805.                 cmap->mp_change[row][i].reg = reg;
  1806.                 ++data; /* skip alpha */
  1807.                 cmap->mp_change[row][i].r = *data++;
  1808.                 cmap->mp_change[row][i].b = *data++;    /* yes, RBG */
  1809.                 cmap->mp_change[row][i].g = *data++;
  1810.                 datasize -= 6;
  1811.                 ++totalchanges;
  1812.             }
  1813.             cmap->mp_change[row][changes].reg = MP_REG_END;
  1814.             --changedlines;
  1815.         }
  1816.         thismask <<= 1;
  1817.         bits--;
  1818.     }
  1819.     if( totalchanges != PCHG->TotalChanges )
  1820.         pm_message("warning - got %ld change structures, chunk header reports %ld", totalchanges, PCHG->TotalChanges);
  1821.     return;
  1822. fail:
  1823.     pm_error("insufficient data in BigLineChanges structures");
  1824. fail2:
  1825.     pm_error("insufficient data in line mask");
  1826. }
  1827.  
  1828.  
  1829. static void
  1830. PCHG_DecompHuff(src, dest, tree, origsize)
  1831.     unsigned char *src, *dest;
  1832.     short *tree;
  1833.     unsigned long origsize;
  1834. {
  1835.     unsigned long i = 0, bits = 0;
  1836.     unsigned char thisbyte;
  1837.     short *p;
  1838.  
  1839.     p = tree;
  1840.     while( i < origsize ) {
  1841.         if( bits == 0 ) {
  1842.             thisbyte = *src++;
  1843.             bits = 8;
  1844.         }
  1845.         if( thisbyte & (1 << 7) ) {
  1846.             if( *p >= 0 ) {
  1847.                 *dest++ = (unsigned char)*p;
  1848.                 i++;
  1849.                 p = tree;
  1850.             }
  1851.             else
  1852.                 p += (*p / 2);
  1853.         }
  1854.         else {
  1855.             p--;
  1856.             if( *p > 0 && (*p & 0x100) ) {
  1857.                 *dest++ = (unsigned char )*p;
  1858.                 i++;
  1859.                 p = tree;
  1860.             }
  1861.         }
  1862.         thisbyte <<= 1;
  1863.         bits--;
  1864.     }
  1865. }
  1866.  
  1867.  
  1868. /****************************************************************************
  1869.  Multipalette handling
  1870.  ****************************************************************************/
  1871.  
  1872.  
  1873. static void
  1874. multi_adjust(cmap, row, palchange)
  1875.     ColorMap *cmap;
  1876.     int row;
  1877.     PaletteChange *palchange;
  1878. {
  1879.     int i, reg;
  1880.  
  1881.     for( i = 0; palchange[i].reg != MP_REG_END; i++ ) {
  1882.         reg = palchange[i].reg;
  1883.         if( reg >= cmap->ncolors ) {
  1884.             pm_message("warning - palette change register out of range");
  1885.             pm_message("    row %d  change structure %d  reg=%d (max %d)", row, i, reg, cmap->ncolors-1);
  1886.             pm_message("    ignoring it... colors might get messed up from here");
  1887.         }
  1888.         else
  1889.         if( reg != MP_REG_IGNORE ) {
  1890.             PPM_ASSIGN(cmap->color[reg], palchange[i].r, palchange[i].g, palchange[i].b);
  1891.         }
  1892.     }
  1893. }
  1894.  
  1895. static void
  1896. multi_init(cmap, viewportmodes)
  1897.     ColorMap *cmap;
  1898.     long viewportmodes;
  1899. {
  1900.     if( cmap->mp_init )
  1901.         multi_adjust(cmap, -1, cmap->mp_init);
  1902.     if( !(viewportmodes & vmLACE) )
  1903.         cmap->mp_flags &= ~(MP_FLAGS_SKIPLACED);
  1904. }
  1905.  
  1906. static void
  1907. multi_update(cmap, row)
  1908.     ColorMap *cmap;
  1909.     int row;
  1910. {
  1911.     if( cmap->mp_flags & MP_FLAGS_SKIPLACED ) {
  1912.         if( odd(row) )
  1913.             return;
  1914.         if( row/2 < cmap->mp_rows && cmap->mp_change[row/2] )
  1915.             multi_adjust(cmap, row, cmap->mp_change[row/2]);
  1916.     }
  1917.     else {
  1918.         if( row < cmap->mp_rows && cmap->mp_change[row] )
  1919.             multi_adjust(cmap, row, cmap->mp_change[row]);
  1920.     }
  1921. }
  1922.  
  1923. static void
  1924. multi_free(cmap)
  1925.     ColorMap *cmap;
  1926. {
  1927.     int i;
  1928.  
  1929.     if( cmap->mp_init ) {
  1930.         free(cmap->mp_init);
  1931.         cmap->mp_init = NULL;
  1932.     }
  1933.     if( cmap->mp_change ) {
  1934.         for( i = 0; i < cmap->mp_rows; i++ ) {
  1935.             if( cmap->mp_change[i] )
  1936.                 free(cmap->mp_change[i]);
  1937.         }
  1938.         free(cmap->mp_change);
  1939.         cmap->mp_change = NULL;
  1940.     }
  1941.     cmap->mp_rows = 0;
  1942.     cmap->mp_type = 0;
  1943.     cmap->mp_flags = 0;
  1944. }
  1945.  
  1946.  
  1947. /****************************************************************************
  1948.  Colormap handling
  1949.  ****************************************************************************/
  1950.  
  1951. static ColorMap *
  1952. alloc_cmap ARGS((void))
  1953. {
  1954.     ColorMap *cmap;
  1955.  
  1956.     cmap = MALLOC(1, ColorMap);
  1957.     cmap->color = NULL;
  1958.     cmap->ncolors = 0;
  1959.     cmap->monolut = cmap->redlut = cmap->greenlut = cmap->bluelut = NULL;
  1960.     cmap->mp_init = NULL;
  1961.     cmap->mp_change = NULL;
  1962.     cmap->mp_rows = cmap->mp_type = cmap->mp_flags = 0;
  1963.     return cmap;
  1964. }
  1965.  
  1966.  
  1967. static void
  1968. check_cmap(bmhd, cmap)
  1969.     BitMapHeader *bmhd;
  1970.     ColorMap *cmap;
  1971. {
  1972.     pixval colmaxval = 0;
  1973.     int shifted = 1;
  1974.     int i, r, g, b;
  1975.  
  1976.     if( bmhd ) {
  1977.         if( bmhd->masking == mskHasTransparentColor || bmhd->masking == mskLasso ) {
  1978.             transpIndex = bmhd->transparentColor;
  1979.             if( !transpName ) {
  1980.                 transpColor = MALLOC(1, pixel);
  1981.                 if( transpIndex >= cmap->ncolors ) {
  1982.                     pm_message("using default transparent color (black)");
  1983.                     PPM_ASSIGN(*transpColor, 0, 0, 0);
  1984.                 }
  1985.                 else
  1986.                     *transpColor = cmap->color[transpIndex];
  1987.             }
  1988.         }
  1989.  
  1990.         if( bmhd->flags & BMHD_FLAGS_CMAPOK )
  1991.             return;
  1992.     }
  1993.  
  1994.     if( !HAS_COLORMAP(cmap) )
  1995.         return;
  1996.  
  1997.     for( i = 0; i < cmap->ncolors; i++ ) {
  1998.         r = PPM_GETR(cmap->color[i]);
  1999.         if( r > colmaxval ) colmaxval = r;
  2000.         if( r & 0x0f ) shifted = 0;
  2001.  
  2002.         g = PPM_GETG(cmap->color[i]);
  2003.         if( g > colmaxval ) colmaxval = g;
  2004.         if( g & 0x0f ) shifted = 0;
  2005.  
  2006.         b = PPM_GETB(cmap->color[i]);
  2007.         if( b > colmaxval ) colmaxval = b;
  2008.         if( b & 0x0f ) shifted = 0;
  2009.     }
  2010.  
  2011. #ifdef DEBUG
  2012.     pm_message("colormap maxval is %d", colmaxval);
  2013. #endif
  2014.     if( colmaxval == 0 )
  2015.         pm_message("warning - black colormap");
  2016.     else
  2017.     if( shifted || colmaxval <= 15 ) {
  2018.         if( !adjustcolors ) {
  2019.             pm_message("warning - probably %s4-bit colormap",
  2020.                         shifted ? "shifted " : "");
  2021.             pm_message("    use \"-adjustcolors\" to scale colormap to 8 bits");
  2022.         }
  2023.         else {
  2024.             pm_message("scaling colormap to 8 bits");
  2025.             for( i = 0; i < cmap->ncolors; i++ ) {
  2026.                 r = PPM_GETR(cmap->color[i]);
  2027.                 g = PPM_GETG(cmap->color[i]);
  2028.                 b = PPM_GETB(cmap->color[i]);
  2029.                 if( shifted ) {
  2030.                     r >>= 4;
  2031.                     g >>= 4;
  2032.                     b >>= 4;
  2033.                 }
  2034.                 r *= FACTOR_4BIT;
  2035.                 g *= FACTOR_4BIT;
  2036.                 b *= FACTOR_4BIT;
  2037.                 PPM_ASSIGN(cmap->color[i], r, g, b);
  2038.             }
  2039.         }
  2040.     }
  2041. }
  2042.  
  2043.  
  2044. static void
  2045. get_color(cmap, idx, red, green, blue)
  2046.     ColorMap *cmap;
  2047.     int idx;
  2048.     pixval *red, *green, *blue;
  2049. {
  2050.     if( HAS_COLORMAP(cmap) ) {
  2051.         pixval r, g, b;
  2052.  
  2053.         if( idx >= cmap->ncolors )
  2054.             pm_error("color index out of range: %d (max %d)", idx, cmap->ncolors);
  2055.         r = PPM_GETR(cmap->color[idx]);
  2056.         g = PPM_GETG(cmap->color[idx]);
  2057.         b = PPM_GETB(cmap->color[idx]);
  2058.  
  2059.         *red    = lookup_red(cmap, r);
  2060.         *green  = lookup_green(cmap, g);
  2061.         *blue   = lookup_blue(cmap, b);
  2062.     }
  2063.     else {
  2064.         *red = *green = *blue = lookup_mono(cmap, idx);
  2065.     }
  2066. }
  2067.  
  2068.  
  2069. static pixval
  2070. lookup_red(cmap, oldval)
  2071.     ColorMap *cmap;
  2072.     int oldval;
  2073. {
  2074.     if( cmap && cmap->redlut && oldval < 256 )
  2075.         return cmap->redlut[oldval];
  2076.     else
  2077.         return oldval;
  2078. }
  2079.  
  2080. static pixval
  2081. lookup_green(cmap, oldval)
  2082.     ColorMap *cmap;
  2083.     int oldval;
  2084. {
  2085.     if( cmap && cmap->greenlut && oldval < 256 )
  2086.         return cmap->greenlut[oldval];
  2087.     else
  2088.         return oldval;
  2089. }
  2090.  
  2091. static pixval
  2092. lookup_blue(cmap, oldval)
  2093.     ColorMap *cmap;
  2094.     int oldval;
  2095. {
  2096.     if( cmap && cmap->bluelut && oldval < 256 )
  2097.         return cmap->bluelut[oldval];
  2098.     else
  2099.         return oldval;
  2100. }
  2101.  
  2102. static pixval
  2103. lookup_mono(cmap, oldval)
  2104.     ColorMap *cmap;
  2105.     int oldval;
  2106. {
  2107.     if( cmap && cmap->monolut && oldval < 256 )
  2108.         return cmap->monolut[oldval];
  2109.     else
  2110.         return oldval;
  2111. }
  2112.  
  2113. static ColorMap *
  2114. ehbcmap(cmap)
  2115.     ColorMap *cmap;
  2116. {
  2117.     pixel *tempcolor = NULL;
  2118.     int i, col;
  2119.  
  2120.     col = cmap->ncolors;
  2121.  
  2122.     tempcolor = ppm_allocrow(col * 2);
  2123.     for( i = 0; i < col; i++ ) {
  2124.         tempcolor[i] = cmap->color[i];
  2125.         PPM_ASSIGN(tempcolor[col + i],  PPM_GETR(cmap->color[i]) / 2,
  2126.                                         PPM_GETG(cmap->color[i]) / 2,
  2127.                                         PPM_GETB(cmap->color[i]) / 2 );
  2128.     }
  2129.     ppm_freerow(cmap->color);
  2130.     cmap->color = tempcolor;
  2131.     cmap->ncolors *= 2;
  2132.  
  2133.     return cmap;
  2134. }
  2135.  
  2136.  
  2137. static pixval
  2138. #if __STDC__
  2139. lut_maxval(ColorMap *cmap, pixval maxval)
  2140. #else
  2141. lut_maxval(cmap, maxval)
  2142.     ColorMap *cmap;
  2143.     pixval maxval;
  2144. #endif
  2145. {
  2146.     int i;
  2147.  
  2148.     if( maxval < 255 ) {
  2149.         if( HAS_COLORLUT(cmap) ) {
  2150.             pixval oldmaxval = maxval;
  2151.             for( i = 0; i < oldmaxval; i++ ) {
  2152.                 if( cmap->redlut   && cmap->redlut[i]   > maxval ) maxval = cmap->redlut[i];
  2153.                 if( cmap->greenlut && cmap->greenlut[i] > maxval ) maxval = cmap->greenlut[i];
  2154.                 if( cmap->bluelut  && cmap->bluelut[i]  > maxval ) maxval = cmap->bluelut[i];
  2155.             }
  2156.             pm_message("warning - %d-bit index into 8-bit color lookup table, table maxval=%d", pm_maxvaltobits(oldmaxval), maxval);
  2157.             if( maxval != oldmaxval )
  2158.                 maxval = 255;
  2159.             pm_message("    assuming image maxval=%d", maxval);
  2160.         }
  2161.     }
  2162.     return maxval;
  2163. }
  2164.  
  2165.  
  2166. /****************************************************************************
  2167.  Basic I/O functions
  2168.  ****************************************************************************/
  2169. static void readerr ARGS((FILE *f, IFF_ID iffid));
  2170.  
  2171.  
  2172. static void
  2173. readerr(f, iffid)
  2174.     FILE *f;
  2175.     IFF_ID iffid;
  2176. {
  2177.     if( ferror(f) )
  2178.         pm_error("read error");
  2179.     else
  2180.         pm_error("premature EOF in %s chunk", ID2string(iffid));
  2181. }
  2182.  
  2183.  
  2184. static void
  2185. read_bytes(ifp, bytes, buffer, iffid, counter)
  2186.     FILE *ifp;
  2187.     int bytes;
  2188.     unsigned char *buffer;
  2189.     IFF_ID iffid;
  2190.     long *counter;
  2191. {
  2192.     if( counter ) {
  2193.         if( *counter < bytes )
  2194.             pm_error("insufficient data in %s chunk", ID2string(iffid));
  2195.         *counter -= bytes;
  2196.     }
  2197.     if( fread(buffer, 1, bytes, ifp) != bytes )
  2198.         readerr(ifp, iffid);
  2199. }
  2200.  
  2201.  
  2202. static unsigned char
  2203. get_byte(ifp, iffid, counter)
  2204.     FILE* ifp;
  2205.     IFF_ID iffid;
  2206.     long *counter;
  2207. {
  2208.     int i;
  2209.  
  2210.     if( counter ) {
  2211.         if( *counter == 0 )
  2212.             pm_error("insufficient data in %s chunk", ID2string(iffid));
  2213.         --(*counter);
  2214.     }
  2215.     i = getc(ifp);
  2216.     if( i == EOF )
  2217.         readerr(ifp, iffid);
  2218.  
  2219.     return (unsigned char) i;
  2220. }
  2221.  
  2222. static long
  2223. get_big_long(ifp, iffid, counter)
  2224.     FILE *ifp;
  2225.     IFF_ID iffid;
  2226.     long *counter;
  2227. {
  2228.     long l;
  2229.  
  2230.     if( counter ) {
  2231.         if( *counter < 4 )
  2232.             pm_error("insufficient data in %s chunk", ID2string(iffid));
  2233.         *counter -= 4;
  2234.     }
  2235.     if( pm_readbiglong(ifp, &l) == -1 )
  2236.         readerr(ifp, iffid);
  2237.  
  2238.     return l;
  2239. }
  2240.  
  2241. static short
  2242. get_big_short(ifp, iffid, counter)
  2243.     FILE *ifp;
  2244.     IFF_ID iffid;
  2245.     long *counter;
  2246. {
  2247.     short s;
  2248.  
  2249.     if( counter ) {
  2250.         if( *counter < 2 )
  2251.             pm_error("insufficient data in %s chunk", ID2string(iffid));
  2252.         *counter -= 2;
  2253.     }
  2254.     if( pm_readbigshort(ifp, &s) == -1 )
  2255.         readerr(ifp, iffid);
  2256.  
  2257.     return s;
  2258. }
  2259.  
  2260.